Iterator Pattern

Iterator Pattern က behaviour pattern တစ်ခုပါ။ Loop ပတ်သည့် အခါမှာ အကုန်လုံးကို ဆွဲထုတ်ပြီး loop ပတ်တာ မဟုတ်ပဲ index နဲ့ ထောက်ပြီး loop ပတ်တာ ဒါမှမဟုတ် tree struture တွေမှာ search method အမျိုးမျိုး နဲ့ ရှာသည့် အခါမှာ သုံးနိုင်ပါတယ်။ Database တွေမှာ data ကို အကုန် ဆွဲထုတ်ပြီး loop ပတ်တာ မဟုတ်ပဲ cursor ကို သုံးပြီး loop လုပ်သည့် သဘောမျိုး နဲ့ လည်း ဆင်ပါတယ်။ တနည်းပြောရင် pointer ထောက် သွားပြီး next နဲ့ သွားသည့် သဘောပါပဲ။

UML class ကို ကြည့်လိုက်ရင် နည်းနည်း ရှုပ်နိုင်ပါတယ်။ Iterator က composite pattern နဲ့ တွဲ သုံးလို့ အဆင်ပြေပါတယ်။

interface MyIterator {
    boolean hasNext();
    Integer next();
}

class MyCollection {
    private Integer[] items;
    private int currentIndex = 0;

    public MyCollection(Integer[] items) {
        this.items = items;
    }

    public boolean hasNext() {
        return currentIndex < items.length;
    }

    public Integer next() {
        if (!hasNext()) {
            return null;
        }
        return items[currentIndex++];
    }
}

public class Main {
    public static void main(String[] args) {
        Integer[] items = {1, 2, 3, 4, 5};
        MyCollection myCollection = new MyCollection(items);

        while (myCollection.hasNext()) {
            System.out.println(myCollection.next());
        }
    }
}

ဒီ code မှာ ဆိုရင် collection ကို loop ပတ်သည့် အခါမှာ collection count နဲ့ မပတ်သွားပဲ hasNext() နဲ့ စစ်ပြီး iteration လုပ်သွားတာကို တွေ့နိုင်ပါတယ်။

Pros and Cons

Single Responsibility ကို လိုက်နာထားပါတယ်။ Class က သူ့ ရဲ့ responsibility ပဲ ရှိပြီး iterator ကို သီးသန့် ခွဲထုတ်ထားပါတယ်။ iterator ကလည်း သူ့ရဲ့ single responsibility ပဲ ရှိပါတယ်။

Open/Closed Principle ကို လိုက်နာထားပါတယ်။ DFSIterator နဲ့ BFSIterator အပြင် အခြား tree အတွက် iterators တစ်ခု ထပ်ဖြည့်ချင်ရင် code အဟောင်းတွေကို ပြင်ဖို့ မလိုပါဘူး။

မကောင်းတာကတော့ over kill ဖြစ်နိုင်တယ်။ ပုံမှန် ရိုးရှင်း သည့် looping တွေမှာ မသုံးသင့်ပါဘူး။